package com.dkm.ec.sale.domain;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import net.sf.json.JSONArray;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import com.dkm.base.api.service.IdGenerator;
import com.dkm.base.core.helper.SpringHelper;
import com.dkm.base.core.util.string.StringUtils;
import com.dkm.biz.domain.AbstractDomain;
import com.dkm.ec.constants.SaleStatConstants;
import com.dkm.ec.sale.persistence.dao.SalePriceDao;
import com.dkm.ec.sale.persistence.dao.SalePriceQueryDao;
import com.dkm.ec.sale.persistence.dao.SaleSkuDao;
import com.dkm.ec.sale.persistence.dao.SaleSkuQueryDao;
import com.dkm.ec.sale.persistence.entity.SaleEntityPo;
import com.dkm.ec.sale.persistence.entity.SalePricePo;
import com.dkm.ec.sale.persistence.entity.SaleSkuPo;
import com.dkm.ec.sale.repository.SaleEntityRepository;
import com.dkm.ec.sale.repository.SalePriceRepository;
import com.dkm.ec.sale.service.SaleSkuService;
import com.dkm.ec.sale.service.SaleSkuStatService;

/**
 * 对象功能:销售产品SKU 领域对象实体
 * 开发公司:SKG.COM
 * 开发人员:Yuki
 * 创建时间:2015-01-22 13:52:18
 */
@Service
@Scope("prototype")
public class SaleSku extends AbstractDomain<String, SaleSkuPo>{
	 @ Resource
	 private SaleSkuDao saleSkuDao;
	 @ Resource
	 private SalePriceDao salePriceDao;
	 @ Resource
	 private SaleSkuQueryDao saleSkuQueryDao;
	 @ Resource
	 private SalePriceQueryDao salePriceQueryDao;
	 @ Resource
	 private SaleSkuService saleSkuService;
	 @Resource
	 private SaleSkuStatService saleSkuStatService;
	 @Resource
	 private SalePriceRepository salePriceRepository ;
	 @Resource
	 private IdGenerator idGenerator;
	 @Resource
	 private SaleEntityRepository saleEntityRepository;
	// @Resource
	 //private AppointDefRepository appointDefRepository;
	 
	 
		private static Logger logger = LoggerFactory.getLogger(SaleSku.class);

	protected void init(){
		saleSkuDao = SpringHelper.getBean(SaleSkuDao.class);
		setDao(saleSkuDao);
	}	 
	 
	public void saveSaleSkusWithSalePrice(String saleSkuJson,String productId) {
		//删除销售价格
		Map<String, Object> params = new HashMap<String, Object>();
		params.put("prodId", productId);
		saleSkuDao.deleteByKey("deleteByProdId", params);
		//再保存一次
		if(StringUtils.isNotEmpty(saleSkuJson)){
			JSONArray jarrry = JSONArray.fromObject(saleSkuJson);
			List<SaleSkuPo> saleSkuPos = JSONArray.toList(jarrry, SaleSkuPo.class);
			for(SaleSkuPo saleSkuPo:saleSkuPos){
				saleSkuPo.setSaleProdId(productId);
				saleSkuPo.setId(getIdGenerator().genSid());
				saleSkuDao.create(saleSkuPo);
				//保存销售价格
				SalePricePo salePricePo = new SalePricePo();
				salePricePo.setId(getIdGenerator().genSid());
				salePricePo.setProdSkuId(saleSkuPo.getId());
				salePricePo.setType(SalePricePo.TYPE.SALESPRICE);
				salePricePo.setPrice(saleSkuPo.getSalesPrice());
				salePricePo.setStatus(saleSkuPo.getStatus());
				salePricePo.setFromTime(new Date());
				salePricePo.setMaxTotal(0);
				salePricePo.setSaleTotal(0);
				salePriceDao.create(salePricePo);
			}
		}
	}
	
	
	/**
	 * 保存商品的sku对象信息和sku对应的销售价格price对象信息（sku，price为1对1关系）
	 * <p>
	 *{ 代码写得太乱了，重构一下，细粒化函数，以便于后期修改和维护
	 * （另：编写复杂业务功能时，请编写方法/接口的功能说明，以便减少开发人员阅读代码时间）}
	 * <p>
	 * @param saleSkuPos --从页面获取sku转化skupo
	 * @param productId
	 */
	public void saveSaleSkusWithSalePrice(List<SaleSkuPo> saleSkuPos,String productId) {
		logger.info("enter [saveSaleSkusWithSalePrice] method, productId="+ productId);
		try {
			if (saleSkuPos != null) {
				List<SaleSkuPo> saleSkuPoList = saleSkuQueryDao.findByProdId(productId); // 获取该商品保存入库的sku
				Integer saleSkuIndex = 0;
				Collections.sort(saleSkuPos,new Comparator<SaleSkuPo>() {
					@Override
					public int compare(SaleSkuPo o1, SaleSkuPo o2) {
						if(o1.getListPrice() > o2.getListPrice()){
							return 1;
						}
						return -1;
					}
				});
				for (SaleSkuPo saleSkuPo : saleSkuPos) {  ///遍历页面获取到的每一个sku对象
					logger.info("【from web】saleSkuPo.id==" + saleSkuPo.getId());
					if (saleSkuIndex == 0) {
						saleSkuPo.setIsDefault("Y");
						saleSkuIndex++;
					} else {
						saleSkuPo.setIsDefault("N");
					}
					
					saleSkuPo.setSaleProdId(productId);
					if (StringUtils.isEmpty(saleSkuPo.getId())) {
						saveSkuPo(saleSkuPo); // ////保存新增sku对象
					} else {
						updateSkuPo(saleSkuPoList, saleSkuPo); // /////更新sku对象
					}
					saveSkuPrice(saleSkuPo); // ///保存销售价格/////
				}
				SaleEntity saleEntity = saleEntityRepository.load(productId);
				SaleEntityPo saleEntityPo = saleEntity.getData();
				removeSkuFromPage(saleSkuPos, saleSkuPoList); // ///deletesku操作（更新库中sku状态）
			}
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}
	}
	
	
	/**
	 * 保存商品的sku对象信息和sku对应的所有价格price对象信息（sku，price为1对1关系）
	 * @param saleSkuPos --从页面获取sku转化skupo
	 * @param productId
	 */
	public void saveSaleSkusWithAllPrice(List<SaleSkuPo> saleSkuPos,String productId) {
		logger.info("enter [saveSaleSkusWithSalePrice] method, productId="+ productId);
		try {
			if (saleSkuPos != null) {
				List<SaleSkuPo> saleSkuPoList = saleSkuQueryDao.findByProdId(productId); // 获取该商品保存入库的sku
				Integer saleSkuIndex = 0;
				Collections.sort(saleSkuPos,new Comparator<SaleSkuPo>() {
					@Override
					public int compare(SaleSkuPo o1, SaleSkuPo o2) {
						if(o1.getListPrice() > o2.getListPrice()){
							return 1;
						}
						return -1;
					}
				});
				for (SaleSkuPo saleSkuPo : saleSkuPos) {  ///遍历页面获取到的每一个sku对象
					logger.info("【from web】saleSkuPo.id==" + saleSkuPo.getId());
					if (saleSkuIndex == 0) {
						saleSkuPo.setIsDefault("Y");
						saleSkuIndex++;
					} else {
						saleSkuPo.setIsDefault("N");
					}
					saleSkuPo.setSaleProdId(productId);
					if (StringUtils.isEmpty(saleSkuPo.getId())) {
						saveSkuPo(saleSkuPo); // ////保存新增sku对象
					} else {
						updateSkuPo(saleSkuPoList, saleSkuPo); // /////更新sku对象
					}
				//	saveSkuAllPrice(saleSkuPo); // ///保存销售价格/////
				}
				//removeSkuFromPage(saleSkuPos, saleSkuPoList); // ///deletesku操作（更新库中sku状态）
			}
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}
	}	

	/**
	 * 用户移除页面sku对象：将对应的数据库sku对象的状态更新为delete，更新key，不删除库
	 * @param saleSkuPos
	 * @param saleSkuPoList
	 */
	private void removeSkuFromPage(List<SaleSkuPo> saleSkuPos,List<SaleSkuPo> saleSkuPoList) {
		for(SaleSkuPo saleSkuPoDB:saleSkuPoList){
			Boolean newFlag=false;
			for(SaleSkuPo poDb:saleSkuPos){ ///存在数据库中，但页面不存在的情况 则flase，向下执行。。
				if(saleSkuPoDB.getId().equals(poDb.getId().trim())){
					logger.info("==============saleSkuPoDB.getId().equals(poDb.getId().trim())===========");
					logger.info("saleSkuPoDB.id="+saleSkuPoDB.getId()+", poDb.id="+poDb.getId());
					newFlag = true;
					break;
				}
			}
			if(!newFlag){	//数据库中的sku在页面没有，则删除（上下架状态的商品）--- 
				Map<String, Object> params = new HashMap<String, Object>();
				params.put("prodSkuId", saleSkuPoDB.getId());
				salePriceDao.updateByKey("updateForDel", params);//逻辑删除sku的销售价对象
				saleSkuService.getSaleSkuForSolr(saleSkuPoDB);	//对saleSkuPoDB构建solr对象
				Map<String, Object> params2 = new HashMap<String, Object>();
				params2.put("id", saleSkuPoDB.getId());
				String skuKey = saleSkuPoDB.getKey();
				if(skuKey.indexOf("_SS_")>-1){
					params2.put("key", saleSkuPoDB.getKey());
				}else{
					params2.put("key", saleSkuPoDB.getKey() + "_SS_" + (new Date()).getTime());
				}
				saleSkuDao.updateByKey("updateForDel", params2);	//逻辑删除sku对象
				//SkuSolr.delete(saleSkuPoDB);//删除solr信息  
			//	SolrSaleUtils.newInstance().delete(saleSkuPoDB.getId());
				logger.info("delete saleSku:"+saleSkuPoDB.getId()+", "+saleSkuPoDB.getKey()+", "+saleSkuPoDB.getSeoKey()+", "+saleSkuPoDB.getCreateBy()); 
			}
		}
	}

	/**
	 * 保存skuPo对应的销售价格对象
	 * 包括：销售价格对象存在和不存在两种情况
	 * @param saleSkuPo
	 */
	private void saveSkuPrice(SaleSkuPo saleSkuPo) {
		SalePricePo salePricePoDB = salePriceQueryDao.getByProdSkuType(saleSkuPo.getId(), SalePricePo.TYPE.SALESPRICE);//根据skuId获取其销售价格对象（1：1）

		if(salePricePoDB!=null){      /////////销售价格对象存在时(存在的sku)
			if(salePricePoDB.getPrice()==null){
				salePricePoDB.setPrice(0.0);
			}
			if(saleSkuPo.getSalesPrice()==null){
				saleSkuPo.setSalesPrice(0.0);
			}
			boolean event=salePricePoDB.getPrice().equals(saleSkuPo.getSalesPrice());
			if(!event){
				salePricePoDB.setPreSalePrice(salePricePoDB.getPrice());
				salePricePoDB.setPrice(saleSkuPo.getSalesPrice());
				salePricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(salePricePoDB);
			//	SaleSkuPriceChangeEvent saleSkuPriceChangeEvent = new SaleSkuPriceChangeEvent(salePricePoDB);
			//	SpringHelper.publishEvent(saleSkuPriceChangeEvent);	
			}else{
				salePricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(salePricePoDB);
			}
		}else{                     ////////////销售价格对象不存在时(不存在的sku)
			SalePricePo salePricePo = new SalePricePo();
			salePricePo.setId(getIdGenerator().genSid());
			salePricePo.setProdSkuId(saleSkuPo.getId());
			salePricePo.setPrice(saleSkuPo.getSalesPrice()==null?0.0:saleSkuPo.getSalesPrice());
			salePricePo.setMaxTotal(saleSkuPo.getMaxTotal()==null?0:saleSkuPo.getMaxTotal());
			salePricePo.setType(SalePricePo.TYPE.SALESPRICE);
			salePricePo.setStatus(saleSkuPo.getStatus());
			salePricePo.setFromTime(new Date());
			salePricePo.setMinNum(1);
			salePricePo.setSaleTotal(0);
			salePriceDao.create(salePricePo);
		}
		
		/*SalePricePo mobilePricePoDB = salePriceQueryDao.getByProdSkuType(saleSkuPo.getId(), SalePricePo.TYPE.MOBILE);
		if(mobilePricePoDB!=null){      /////////销售价格对象存在时(存在的sku)
			if(mobilePricePoDB.getPrice()==null){
				mobilePricePoDB.setPrice(0.0);
			}
			if(saleSkuPo.getSalesPrice()==null){
				saleSkuPo.setSalesPrice(0.0);
			}
			boolean event=mobilePricePoDB.getPrice().equals(saleSkuPo.getMobilePrice());
			if(!event){
				mobilePricePoDB.setPreSalePrice(mobilePricePoDB.getPrice());
				mobilePricePoDB.setPrice(saleSkuPo.getMobilePrice());
				mobilePricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(mobilePricePoDB);
			//	SaleSkuPriceChangeEvent saleSkuPriceChangeEvent = new SaleSkuPriceChangeEvent(mobilePricePoDB);
			//	SpringHelper.publishEvent(saleSkuPriceChangeEvent);	
			}else{
				mobilePricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(mobilePricePoDB);
			}
		}else{                     ////////////销售价格对象不存在时(不存在的sku)
			SalePricePo salePricePo = new SalePricePo();
			salePricePo.setId(getIdGenerator().genSid());
			salePricePo.setProdSkuId(saleSkuPo.getId());
			salePricePo.setPrice(saleSkuPo.getMobilePrice()==null?0.0:saleSkuPo.getMobilePrice());
			salePricePo.setMaxTotal(saleSkuPo.getMaxTotal()==null?0:saleSkuPo.getMaxTotal());
			salePricePo.setType(SalePricePo.TYPE.MOBILE);
			salePricePo.setStatus(saleSkuPo.getStatus());
			salePricePo.setFromTime(new Date());
			salePricePo.setMinNum(1);
			salePricePo.setSaleTotal(0);
			salePriceDao.create(salePricePo);
		}	*/
		//
		SalePricePo pointPricePoDB = salePriceQueryDao.getByProdSkuType(saleSkuPo.getId(), SalePricePo.TYPE.POINT);
		if(pointPricePoDB!=null){      /////////销售价格对象存在时(存在的sku)
			if(pointPricePoDB.getPrice()==null){
				pointPricePoDB.setPrice(0.0);
			}
			if(saleSkuPo.getSalesPrice()==null){
				saleSkuPo.setSalesPrice(0.0);
			}
			boolean event=pointPricePoDB.getPrice().equals(saleSkuPo.getPoint());
			if(!event){
				pointPricePoDB.setPreSalePrice(pointPricePoDB.getPrice());
				pointPricePoDB.setPrice(saleSkuPo.getPoint());
				pointPricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(pointPricePoDB);
			//	SaleSkuPriceChangeEvent saleSkuPriceChangeEvent = new SaleSkuPriceChangeEvent(mobilePricePoDB);
			//	SpringHelper.publishEvent(saleSkuPriceChangeEvent);	
			}else{
				pointPricePoDB.setMaxTotal(saleSkuPo.getMaxTotal());
				salePriceDao.update(pointPricePoDB);
			}
		}else{                     ////////////销售价格对象不存在时(不存在的sku)
			SalePricePo salePricePo = new SalePricePo();
			salePricePo.setId(getIdGenerator().genSid());
			salePricePo.setProdSkuId(saleSkuPo.getId());
			salePricePo.setPrice(saleSkuPo.getPoint()==null?0.0:saleSkuPo.getPoint());
			salePricePo.setMaxTotal(saleSkuPo.getMaxTotal()==null?0:saleSkuPo.getMaxTotal());
			salePricePo.setType(SalePricePo.TYPE.POINT);
			salePricePo.setStatus(saleSkuPo.getStatus());
			salePricePo.setFromTime(new Date());
			salePricePo.setMinNum(1);
			salePricePo.setSaleTotal(0);
			salePriceDao.create(salePricePo);
		}	
	}
	
	/**
	 * 保存skuPo对应的销售价格对象
	 * 包括：销售价格对象存在和不存在两种情况
	 * @param saleSkuPo
	 */
	private void saveSkuAllPrice(SaleSkuPo saleSkuPo) {
		List<SalePricePo> salePricePos =saleSkuPo.getSalePricePos() ;
			for(SalePricePo salePricePo :salePricePos ){ 
					salePricePo.setId(idGenerator.genSid());
					salePricePo.setSaleTotal(0);
					salePricePo.setStatus("on_sale");
					salePricePo.setProdSkuId(saleSkuPo.getId());
					salePriceDao.create(salePricePo); 

			//		SaleSkuPriceChangeEvent saleSkuPriceChangeEvent = new SaleSkuPriceChangeEvent(salePricePo);
				//	SpringHelper.publishEvent(saleSkuPriceChangeEvent);						
					
				}
			}

	/**
	 * 更新一个skuPo对象，同时更新其solr
	 * <p>
	 * {获取到该skuPo对应的数据库skuDB对象;
	 * 这里代码写得有点乱，这里应该使用saleSkuPo的Id去获取库中的
	 * saleSkuDB对象，然后再更新，找不到则create。但是源代码却去循环数据库！实在令人疑惑不已。
	 * 另外：程序中存在无效代码和重复代码
	 * }<p>
	 * 
	 * @param saleSkuPoList
	 * @param saleSkuPo
	 */
	private void updateSkuPo( List<SaleSkuPo> saleSkuPoList,SaleSkuPo saleSkuPo) {
		Boolean dbFlag = false;////skuPo对象对应的库中没有，则重新生成
//		List<String> ids=new ArrayList<String>();
//		ids.add(saleSkuPo.getId()); //这个是垃圾代码吗吗？
		for(SaleSkuPo saleSkuPoDB:saleSkuPoList){
			if(saleSkuPoDB.getStatus().equals("delete"))continue;
			logger.info("saleSkuPoDB.id="+saleSkuPoDB.getId());
			logger.info("saleSkuPo.id="+saleSkuPo.getId());
			
			
			SaleEntity saleEntity = saleEntityRepository.load(saleSkuPo.getSaleProdId());
			SaleEntityPo  saEntityPo =saleEntity.getData();
			if((saleSkuPo.getId()).trim().equals((saleSkuPoDB.getId()).trim())){ 
				logger.info("==========(saleSkuPo.getId()).trim().equals((saleSkuPoDB.getId()).trim())===========");
				saleSkuPoDB.setSaleProdId(saleSkuPo.getSaleProdId());
				saleSkuPoDB.setCreateType(saleSkuPo.getCreateType());
				saleSkuPoDB.setKey(saleSkuPo.getKey());
				saleSkuPoDB.setOpKey(saleSkuPo.getOpKey());
				saleSkuPoDB.setSeoKey(saleSkuPo.getSeoKey());
				saleSkuPoDB.setAttrIds(saleSkuPo.getAttrIds());
				saleSkuPoDB.setAttrOpIds(saleSkuPo.getAttrOpIds());
				saleSkuPoDB.setAttrOpLabels(saleSkuPo.getAttrOpLabels());
				saleSkuPoDB.setAttrOpValues(saleSkuPo.getAttrOpValues());
				saleSkuPoDB.setAttrNames(saleSkuPo.getAttrNames());
				saleSkuPoDB.setLength(saleSkuPo.getLength());
				saleSkuPoDB.setWidth(saleSkuPo.getWidth());
				saleSkuPoDB.setHeight(saleSkuPo.getHeight());
				saleSkuPoDB.setWeight(saleSkuPo.getWeight());
				saleSkuPoDB.setListPrice(saleSkuPo.getListPrice());
				saleSkuPoDB.setPointCount(saleSkuPo.getPointCount());
				saleSkuPoDB.setStatus(saleSkuPo.getStatus());
				saleSkuPoDB.setSkuName(saleSkuPo.getSkuName());
				saleSkuPoDB.setSalesPrice(saleSkuPo.getSalesPrice());
				saleSkuPoDB.setIsDefault(saleSkuPo.getIsDefault());
				saleSkuDao.update(saleSkuPoDB);
				if (!saEntityPo.getSalesType().equals("rush")){
					//
					if(saEntityPo.getSeType().toLowerCase().equals("package")||saEntityPo.getIsSearch().equals("N")){
//						SkuSolr.delete(saleSkuPoDB.getId());
					//	SolrSaleUtils.newInstance().delete(saleSkuPoDB.getId());
					}else{
						saleSkuService.getSaleSkuForSolr(saleSkuPoDB);
//						SkuSolr.update(saleSkuPoDB);	//更新solr	
					//	SolrSaleUtils.newInstance().add(saleSkuPoDB); 
					}
					
				}else {
					try {
//						SkuSolr.delete(saleSkuPoDB);//删除solr信息
					//	SolrSaleUtils.newInstance().delete(saleSkuPoDB.getId());
					} catch (Exception e) {
						logger.info("solr中没有此sku"+saleSkuPoDB.getId());
						e.printStackTrace();
					}
				}
				dbFlag=true;
				logger.info("set dbFlag=true");
				break;
			}
		}
		if(!dbFlag){
			saleSkuDao.create(saleSkuPo);
			logger.warn("-------------------------Sale Sku Create2:"+saleSkuPo.getId()+", "+saleSkuPo.getKey()+", "+saleSkuPo.getSeoKey()+", "+saleSkuPo.getCreateBy());
			
			saleSkuService.getSaleSkuForSolr(saleSkuPo);	//add solr
			if(!saleSkuPo.getSaleEntityPo().getSeType().toLowerCase().equals("package")&&saleSkuPo.getSaleEntityPo().getIsSearch().equals("Y") ){
//				SkuSolr.add(saleSkuPo);	
		//		SolrSaleUtils.newInstance().add(saleSkuPo);
			}
			
		}
	}

	/**
	 * 保存新增sku对象，同时对skuPo重构到solr
	 * @param saleSkuPo
	 */
	private void saveSkuPo(SaleSkuPo saleSkuPo) {
		//saleSkuPo.setKey(idGenerator.genSid());
		saleSkuPo.setStatus("on_sale");
		logger.info("saleSkuPo.getId()=null");
		saleSkuPo.setId(getIdGenerator().genSid());
		saleSkuDao.create(saleSkuPo);
		logger.info("-------------------------Sale Sku Create:"+saleSkuPo.getKey()+saleSkuPo.getSeoKey()+saleSkuPo.getCreateBy());
		saleSkuStatService.addSkuStat(saleSkuPo.getSaleProdId(), saleSkuPo.getId(), SaleStatConstants.TYPE_REVIEW, 0,new BigDecimal(0));
		
		//增加判断，如果是按库存销售类型，则保存solr，否则不保存
		SaleEntity saleEntity = saleEntityRepository.load(saleSkuPo.getSaleProdId());
		SaleEntityPo  saEntityPo =saleEntity.getData();
		if(!saEntityPo.getSalesType().equals("rush")){ 
			if(!saEntityPo.getSeType().toLowerCase().equals("package")&&saEntityPo.getIsSearch().equals("Y")){
				//若是套餐，则不存到solr
				saleSkuService.getSaleSkuForSolr(saleSkuPo); 	//重构solr
//				SkuSolr.add(saleSkuPo);//此次saleskuPO應該有圖片信息getProductMediaPoList
			//	SolrSaleUtils.newInstance().add(saleSkuPo);
				
			}
			
		}else {
			logger.info("sku类型为rush..不add solr");
		}
		
	}
	
	/**
	 * 根据销售类型获取对应的价格
	 * @param saleSkuPo
	 * @return
	 */
	public void setSalePrice(SaleSkuPo saleSkuPo, String partyId){
		Double salePrice = 0d;
		String priceType = "sales_price";
		if(saleSkuPo != null){
			SaleEntity saleEntity = saleEntityRepository.load(saleSkuPo.getSaleProdId());
			if(saleEntity != null){
				if("rush".equals(saleEntity.getData().getSalesType())){
					//抢购活动，判断会员有没预约，有预约的用预约价，不然用销售价
					/*if(appointDefRepository.hasAppoint(partyId)){
						priceType = "rush";
					}*/
				}
			}
		}
		
		List<SalePricePo> salePricePos = salePriceRepository.findBySkuId(saleSkuPo.getId());
		if(salePricePos != null && salePricePos.size() > 0){
			for(SalePricePo salePricePo : salePricePos){
				if(priceType.equals(salePricePo.getType())&& "on_sale".equals(salePricePo.getStatus())){
					if(salePricePo.getFromTime() != null && salePricePo.getToTime() != null){
						if((new Date()).after(salePricePo.getFromTime()) && (new Date()).before(salePricePo.getToTime())){
							salePrice = salePricePo.getPrice();
							break;
						}
					}else{
						salePrice = salePricePo.getPrice();
						break;
					}
				}
			}
			
			if(salePrice <= 0d){
				for(SalePricePo salePricePo : salePricePos){
					if("sales_price".equals(salePricePo.getType())){
						salePrice = salePricePo.getPrice();
						break;
					}
				}
			}
		}
		saleSkuPo.setSalesPrice(salePrice);
	}
}
